टाइपस्क्रिप्ट जेनरिक: मजबूत अनुप्रयोगों के लिए जटिल डेटा प्रकारों में महारत हासिल करना

टाइपस्क्रिप्ट, जो जावास्क्रिप्ट का एक सुपरसेट है, डेवलपर्स को स्टैटिक टाइपिंग के माध्यम से अधिक मजबूत और रखरखाव योग्य कोड लिखने की शक्ति देता है। इसकी सबसे शक्तिशाली विशेषताओं में से एक जेनरिक है, जो आपको विभिन्न प्रकार के डेटा प्रकारों के साथ काम करने वाला कोड लिखने की अनुमति देता है, जबकि टाइप सुरक्षा बनाए रखता है। यह गाइड टाइपस्क्रिप्ट जेनरिक की एक व्यापक खोज प्रदान करता है, जो वैश्विक सॉफ्टवेयर विकास के संदर्भ में जटिल डेटा प्रकारों पर उनके अनुप्रयोग पर ध्यान केंद्रित करता है।

जेनरिक क्या हैं?

जेनरिक पुन: प्रयोज्य कोड लिखने का एक तरीका प्रदान करते हैं जो विभिन्न प्रकारों के साथ काम कर सकता है। प्रत्येक प्रकार के लिए अलग-अलग फ़ंक्शन या क्लास लिखने के बजाय, आप एक एकल फ़ंक्शन या क्लास लिख सकते हैं जो टाइप पैरामीटर का उपयोग करता है। ये टाइप पैरामीटर उन वास्तविक प्रकारों के लिए प्लेसहोल्डर हैं जिनका उपयोग तब किया जाएगा जब फ़ंक्शन या क्लास को कॉल या इंस्टेंटियेट किया जाता है। यह विशेष रूप से जटिल डेटा संरचनाओं से निपटने के दौरान उपयोगी होता है जहां उन संरचनाओं के भीतर डेटा का प्रकार भिन्न हो सकता है।

जेनरिक का उपयोग करने के लाभ

• कोड पुनरुपयोग: एक बार कोड लिखें और इसे विभिन्न प्रकारों के साथ उपयोग करें। यह कोड दोहराव को कम करता है और आपके कोडबेस को अधिक रखरखाव योग्य बनाता है।
• टाइप सुरक्षा: जेनरिक टाइपस्क्रिप्ट कंपाइलर को कंपाइल समय पर टाइप सुरक्षा लागू करने की अनुमति देते हैं। यह टाइप बेमेल से संबंधित रनटाइम त्रुटियों को रोकने में मदद करता है।
• बेहतर पठनीयता: जेनरिक आपके कोड को अधिक पठनीय बनाते हैं क्योंकि वे स्पष्ट रूप से उन प्रकारों को इंगित करते हैं जिनके साथ आपके फ़ंक्शन और क्लास काम करने के लिए डिज़ाइन किए गए हैं।
• उन्नत प्रदर्शन: कुछ मामलों में, जेनरिक प्रदर्शन में सुधार कर सकते हैं क्योंकि कंपाइलर उपयोग किए जा रहे विशिष्ट प्रकारों के आधार पर उत्पन्न कोड को अनुकूलित कर सकता है।

जेनरिक का मूल सिंटैक्स

जेनरिक के मूल सिंटैक्स में टाइप पैरामीटर घोषित करने के लिए एंगल ब्रैकेट (< >) का उपयोग करना शामिल है। इन टाइप पैरामीटरों को आम तौर पर T, K, V, आदि नाम दिया जाता है, लेकिन आप किसी भी मान्य पहचानकर्ता का उपयोग कर सकते हैं। यहाँ एक जेनरिक फ़ंक्शन का एक सरल उदाहरण है:

function identity<T>(arg: T): T {
  return arg;
}

let myString: string = identity<string>("hello");
let myNumber: number = identity<number>(123);
let myBoolean: boolean = identity<boolean>(true);

console.log(myString); // Output: hello
console.log(myNumber); // Output: 123
console.log(myBoolean); // Output: true

इस उदाहरण में, <T> एक टाइप पैरामीटर घोषित करता है जिसका नाम T है। फ़ंक्शन identity टाइप T का एक आर्ग्यूमेंट लेता है और टाइप T का एक मान लौटाता है। फ़ंक्शन को कॉल करते समय, आप स्पष्ट रूप से टाइप पैरामीटर निर्दिष्ट कर सकते हैं (जैसे, identity<string>) या टाइपस्क्रिप्ट को आर्ग्यूमेंट प्रकार के आधार पर इसका अनुमान लगाने दे सकते हैं।

जटिल डेटा प्रकारों के साथ काम करना

जेनरिक विशेष रूप से तब मूल्यवान हो जाते हैं जब ऐरे, ऑब्जेक्ट्स और इंटरफेस जैसे जटिल डेटा प्रकारों से निपटना होता है। आइए कुछ सामान्य परिदृश्यों का पता लगाएं:

जेनरिक ऐरे (Arrays)

आप विभिन्न प्रकार के ऐरे के साथ काम करने वाले फ़ंक्शन या क्लास बनाने के लिए जेनरिक का उपयोग कर सकते हैं:

function arrayToString<T>(arr: T[]): string {
  return arr.join(", ");
}

let numberArray: number[] = [1, 2, 3, 4, 5];
let stringArray: string[] = ["apple", "banana", "cherry"];

console.log(arrayToString(numberArray)); // Output: 1, 2, 3, 4, 5
console.log(arrayToString(stringArray)); // Output: apple, banana, cherry

यहां, arrayToString फ़ंक्शन टाइप T[] का एक ऐरे लेता है और ऐरे का एक स्ट्रिंग प्रतिनिधित्व लौटाता है। यह फ़ंक्शन किसी भी प्रकार के ऐरे के साथ काम करता है, जो इसे अत्यधिक पुन: प्रयोज्य बनाता है।

जेनरिक ऑब्जेक्ट्स (Objects)

जेनरिक का उपयोग उन फ़ंक्शन या क्लास को परिभाषित करने के लिए भी किया जा सकता है जो विभिन्न आकृतियों की वस्तुओं के साथ काम करते हैं:

interface Person {
  name: string;
  age: number;
  country: string; // Added country for global context
}

interface Product {
  id: number;
  name: string;
  price: number;
  currency: string; // Added currency for global context
}

function displayInfo<T extends { name: string }>(item: T): void {
  console.log(`Name: ${item.name}`);
}

let person: Person = { name: "Alice", age: 30, country: "USA" };
let product: Product = { id: 1, name: "Laptop", price: 1200, currency: "USD" };

displayInfo(person); // Output: Name: Alice
displayInfo(product); // Output: Name: Laptop

इस उदाहरण में, displayInfo फ़ंक्शन टाइप T का एक ऑब्जेक्ट लेता है जिसमें स्ट्रिंग प्रकार की एक name प्रॉपर्टी होनी चाहिए। extends { name: string } क्लॉज एक कंस्ट्रेंट (constraint) है, जो टाइप पैरामीटर T के लिए न्यूनतम आवश्यकताओं को निर्दिष्ट करता है। यह सुनिश्चित करता है कि फ़ंक्शन सुरक्षित रूप से name प्रॉपर्टी तक पहुंच सकता है।

उन्नत जेनरिक उपयोग

टाइपस्क्रिप्ट जेनरिक अधिक उन्नत सुविधाएँ प्रदान करते हैं जो आपको और भी अधिक लचीला और शक्तिशाली कोड बनाने की अनुमति देती हैं। आइए इनमें से कुछ विशेषताओं का पता लगाएं:

एकाधिक टाइप पैरामीटर

आप एकाधिक टाइप पैरामीटर के साथ फ़ंक्शन या क्लास परिभाषित कर सकते हैं:

function merge<T, U>(obj1: T, obj2: U): T & U {
  return { ...obj1, ...obj2 };
}

interface Name {
  firstName: string;
}

interface Age {
  age: number;
}

const person: Name = { firstName: "Bob" };
const details: Age = { age: 42 };

const merged = merge(person, details);
console.log(merged.firstName); // Output: Bob
console.log(merged.age); // Output: 42

merge फ़ंक्शन T और U प्रकार के दो ऑब्जेक्ट लेता है और एक नया ऑब्जेक्ट लौटाता है जिसमें दोनों ऑब्जेक्ट्स के गुण होते हैं। यह विभिन्न स्रोतों से डेटा को संयोजित करने का एक शक्तिशाली तरीका है।

जेनरिक कंस्ट्रेंट्स (Constraints)

जैसा कि पहले दिखाया गया है, कंस्ट्रेंट्स आपको उन प्रकारों को प्रतिबंधित करने की अनुमति देते हैं जिनका उपयोग जेनरिक टाइप पैरामीटर के साथ किया जा सकता है। यह सुनिश्चित करता है कि जेनरिक कोड निर्दिष्ट प्रकारों पर सुरक्षित रूप से काम कर सकता है।

interface Lengthwise {
  length: number;
}

function loggingIdentity<T extends Lengthwise>(arg: T): T {
  console.log(arg.length);
  return arg;
}

loggingIdentity([1, 2, 3]); // Output: 3
loggingIdentity("hello"); // Output: 5
// loggingIdentity(123); // Error: Argument of type 'number' is not assignable to parameter of type 'Lengthwise'.

loggingIdentity फ़ंक्शन टाइप T का एक आर्ग्यूमेंट लेता है जिसमें नंबर प्रकार की length प्रॉपर्टी होनी चाहिए। यह सुनिश्चित करता है कि फ़ंक्शन सुरक्षित रूप से length प्रॉपर्टी तक पहुंच सकता है।

जेनरिक क्लासेस (Classes)

जेनरिक का उपयोग क्लास के साथ भी किया जा सकता है:

class DataStorage<T> {
  private data: T[] = [];

  addItem(item: T) {
    this.data.push(item);
  }

  removeItem(item: T) {
    this.data = this.data.filter(d => d !== item);
  }

  getItems(): T[] {
    return [...this.data];
  }
}

const textStorage = new DataStorage<string>();
textStorage.addItem("apple");
textStorage.addItem("banana");
textStorage.removeItem("apple");
console.log(textStorage.getItems()); // Output: [ 'banana' ]

const numberStorage = new DataStorage<number>();
numberStorage.addItem(1);
numberStorage.addItem(2);
numberStorage.removeItem(1);
console.log(numberStorage.getItems()); // Output: [ 2 ]

DataStorage क्लास किसी भी प्रकार T के डेटा को स्टोर कर सकती है। यह आपको पुन: प्रयोज्य डेटा संरचनाएं बनाने की अनुमति देता है जो टाइप-सेफ हैं।

जेनरिक इंटरफेस (Interfaces)

जेनरिक इंटरफेस उन अनुबंधों को परिभाषित करने के लिए उपयोगी होते हैं जो विभिन्न प्रकारों के साथ काम कर सकते हैं। उदाहरण के लिए:

interface Result<T, E> {
  success: boolean;
  data?: T;
  error?: E;
}

interface User {
  id: number;
  username: string;
  email: string;
}

interface ErrorMessage {
  code: number;
  message: string;
}

function fetchUser(id: number): Result<User, ErrorMessage> {
  if (id === 1) {
    return { success: true, data: { id: 1, username: "john.doe", email: "john.doe@example.com" } };
  } else {
    return { success: false, error: { code: 404, message: "User not found" } };
  }
}

const userResult = fetchUser(1);
if (userResult.success) {
  console.log(userResult.data.username);
} else {
  console.log(userResult.error.message);
}

Result इंटरफ़ेस किसी ऑपरेशन के परिणाम का प्रतिनिधित्व करने के लिए एक जेनरिक संरचना को परिभाषित करता है। इसमें या तो टाइप T का डेटा हो सकता है या टाइप E की कोई त्रुटि हो सकती है। यह एसिंक्रोनस संचालन या विफल हो सकने वाले संचालन को संभालने के लिए एक सामान्य पैटर्न है।

यूटिलिटी टाइप्स और जेनरिक

टाइपस्क्रिप्ट कई अंतर्निहित यूटिलिटी टाइप्स प्रदान करता है जो जेनरिक के साथ अच्छी तरह से काम करते हैं। ये यूटिलिटी टाइप्स आपको शक्तिशाली तरीकों से प्रकारों को बदलने और हेरफेर करने में मदद कर सकते हैं।

Partial<T>

Partial<T> टाइप T की सभी प्रॉपर्टी को वैकल्पिक बनाता है:

interface Person {
  name: string;
  age: number;
}

type PartialPerson = Partial<Person>;

const partialPerson: PartialPerson = { name: "Alice" }; // Valid

Readonly<T>

Readonly<T> टाइप T की सभी प्रॉपर्टी को केवल-पठनीय बनाता है:

interface Person {
  name: string;
  age: number;
}

type ReadonlyPerson = Readonly<Person>;

const readonlyPerson: ReadonlyPerson = { name: "Bob", age: 42 };
// readonlyPerson.age = 43; // Error: Cannot assign to 'age' because it is a read-only property.

Pick<T, K>

Pick<T, K> टाइप T से प्रॉपर्टी K का एक सेट चुनता है:

interface Person {
  name: string;
  age: number;
  email: string;
}

type NameAndAge = Pick<Person, "name" | "age">;

const nameAndAge: NameAndAge = { name: "Charlie", age: 28 };

Omit<T, K>

Omit<T, K> टाइप T से प्रॉपर्टी K का एक सेट हटाता है:

interface Person {
  name: string;
  age: number;
  email: string;
}

type PersonWithoutEmail = Omit<Person, "email">;

const personWithoutEmail: PersonWithoutEmail = { name: "David", age: 35 };

Record<K, T>

Record<K, T> कीज़ K और टाइप T के मानों के साथ एक टाइप बनाता है:

type CountryCodes = "US" | "CA" | "UK" | "DE" | "FR" | "JP" | "CN" | "IN" | "BR" | "AU"; // Expanded list for global context
type Currency = "USD" | "CAD" | "GBP" | "EUR" | "JPY" | "CNY" | "INR" | "BRL" | "AUD"; // Expanded list for global context

type CurrencyMap = Record<CountryCodes, Currency>;

const currencyMap: CurrencyMap = {
  "US": "USD",
  "CA": "CAD",
  "UK": "GBP",
  "DE": "EUR",
  "FR": "EUR",
  "JP": "JPY",
  "CN": "CNY",
  "IN": "INR",
  "BR": "BRL",
  "AU": "AUD",
};

मैप्ड टाइप्स (Mapped Types)

मैप्ड टाइप्स आपको मौजूदा प्रकारों को उनकी प्रॉपर्टी पर पुनरावृति करके बदलने की अनुमति देते हैं। यह मौजूदा प्रकारों के आधार पर नए प्रकार बनाने का एक शक्तिशाली तरीका है। उदाहरण के लिए, आप एक ऐसा प्रकार बना सकते हैं जो दूसरे प्रकार की सभी प्रॉपर्टी को केवल-पठनीय बनाता है:

interface Person {
  name: string;
  age: number;
}

type ReadonlyPerson = {
  readonly [K in keyof Person]: Person[K];
};

const readonlyPerson: ReadonlyPerson = { name: "Eve", age: 25 };
// readonlyPerson.age = 26; // Error: Cannot assign to 'age' because it is a read-only property.

इस उदाहरण में, [K in keyof Person] Person इंटरफ़ेस की सभी कीज़ पर पुनरावृति करता है, और Person[K] प्रत्येक प्रॉपर्टी के प्रकार तक पहुंचता है। readonly कीवर्ड प्रत्येक प्रॉपर्टी को केवल-पठनीय बनाता है।

कंडीशनल टाइप्स (Conditional Types)

कंडीशनल टाइप्स आपको शर्तों के आधार पर प्रकारों को परिभाषित करने की अनुमति देते हैं। यह उन प्रकारों को बनाने का एक शक्तिशाली तरीका है जो विभिन्न परिदृश्यों के अनुकूल होते हैं।

type NonNullable<T> = T extends null | undefined ? never : T;

type MaybeString = string | null | undefined;
type StringType = NonNullable<MaybeString>; // string

function getValue<T>(value: T): NonNullable<T> {
  if (value == null) { // Handles both null and undefined
    throw new Error("Value cannot be null or undefined");
  }
  return value as NonNullable<T>;
}

try {
  const validValue = getValue("hello");
  console.log(validValue.toUpperCase()); // Output: HELLO

  const invalidValue = getValue(null); // This will throw an error
  console.log(invalidValue); // This line will not be reached
} catch (error: any) {
  console.error(error.message); // Output: Value cannot be null or undefined
}

इस उदाहरण में, NonNullable<T> प्रकार जाँचता है कि T null या undefined है या नहीं। यदि है, तो यह never लौटाता है, जिसका अर्थ है कि प्रकार की अनुमति नहीं है। अन्यथा, यह T लौटाता है। यह आपको ऐसे प्रकार बनाने की अनुमति देता है जो गैर-शून्य होने की गारंटी देते हैं।

जेनरिक का उपयोग करने के लिए सर्वोत्तम अभ्यास

जेनरिक का उपयोग करते समय ध्यान रखने योग्य कुछ सर्वोत्तम अभ्यास यहां दिए गए हैं:

• वर्णनात्मक टाइप पैरामीटर नामों का उपयोग करें: ऐसे नाम चुनें जो टाइप पैरामीटर के उद्देश्य को स्पष्ट रूप से इंगित करते हों।
• जेनरिक टाइप पैरामीटर के साथ उपयोग किए जा सकने वाले प्रकारों को सीमित करने के लिए कंस्ट्रेंट्स का उपयोग करें: यह सुनिश्चित करता है कि आपका जेनरिक कोड निर्दिष्ट प्रकारों पर सुरक्षित रूप से काम कर सकता है।
• अपने जेनरिक कोड को सरल और केंद्रित रखें: बहुत अधिक टाइप पैरामीटर या जटिल कंस्ट्रेंट्स के साथ अपने जेनरिक कोड को अधिक जटिल बनाने से बचें।
• अपने जेनरिक कोड का पूरी तरह से दस्तावेजीकरण करें: टाइप पैरामीटर के उद्देश्य और उपयोग किए गए किसी भी कंस्ट्रेंट्स की व्याख्या करें।
• कोड पुनरुपयोग और टाइप सुरक्षा के बीच ट्रेड-ऑफ पर विचार करें: जबकि जेनरिक कोड पुनरुपयोग में सुधार कर सकते हैं, वे आपके कोड को और अधिक जटिल भी बना सकते हैं। जेनरिक का उपयोग करने से पहले लाभ और कमियों का मूल्यांकन करें।
• स्थानीयकरण और वैश्वीकरण (l10n और g11n) पर विचार करें: जब ऐसे डेटा से निपटते हैं जिसे विभिन्न क्षेत्रों में उपयोगकर्ताओं को प्रदर्शित करने की आवश्यकता होती है, तो सुनिश्चित करें कि आपके जेनरिक उचित स्वरूपण और सांस्कृतिक परंपराओं का समर्थन करते हैं। उदाहरण के लिए, संख्या और दिनांक स्वरूपण स्थानों के बीच काफी भिन्न हो सकते हैं।

वैश्विक संदर्भ में उदाहरण

आइए कुछ उदाहरणों पर विचार करें कि वैश्विक संदर्भ में जेनरिक का उपयोग कैसे किया जा सकता है:

मुद्रा रूपांतरण

interface ConversionRate {
  rate: number;
  fromCurrency: string;
  toCurrency: string;
}

function convertCurrency<T extends ConversionRate>(amount: number, rate: T): number {
  return amount * rate.rate;
}

const usdToEurRate: ConversionRate = { rate: 0.85, fromCurrency: "USD", toCurrency: "EUR" };
const amountInUSD = 100;
const amountInEUR = convertCurrency(amountInUSD, usdToEurRate);
console.log(`${amountInUSD} USD is equal to ${amountInEUR} EUR`); // Output: 100 USD is equal to 85 EUR

दिनांक स्वरूपण

interface DateFormatOptions {
  locale: string;
  options: Intl.DateTimeFormatOptions;
}

function formatDate<T extends DateFormatOptions>(date: Date, format: T): string {
  return date.toLocaleDateString(format.locale, format.options);
}

const currentDate = new Date();

const usDateFormat: DateFormatOptions = { locale: "en-US", options: { year: 'numeric', month: 'long', day: 'numeric' } };
const germanDateFormat: DateFormatOptions = { locale: "de-DE", options: { year: 'numeric', month: 'long', day: 'numeric' } };
const japaneseDateFormat: DateFormatOptions = { locale: "ja-JP", options: { year: 'numeric', month: 'long', day: 'numeric' } };

console.log("US Date: " + formatDate(currentDate, usDateFormat));
console.log("German Date: " + formatDate(currentDate, germanDateFormat));
console.log("Japanese Date: " + formatDate(currentDate, japaneseDateFormat));

अनुवाद सेवा

interface Translation {
  [key: string]: string; // Allows for dynamic language keys
}

interface LanguageData<T extends Translation> {
  languageCode: string;
  translations: T;
}

const englishTranslations: Translation = {
  "hello": "Hello",
  "goodbye": "Goodbye",
  "welcome": "Welcome to our website!"
};

const spanishTranslations: Translation = {
  "hello": "Hola",
  "goodbye": "Adiós",
  "welcome": "¡Bienvenido a nuestro sitio web!"
};

const frenchTranslations: Translation = {
  "hello": "Bonjour",
  "goodbye": "Au revoir",
  "welcome": "Bienvenue sur notre site web !"
};


const languageData: LanguageData<typeof englishTranslations>[] = [
  {languageCode: "en", translations: englishTranslations },
  {languageCode: "es", translations: spanishTranslations },
  {languageCode: "fr", translations: frenchTranslations}
];

function translate<T extends Translation>(key: string, languageCode: string, languageData: LanguageData<T>[]): string {
  const lang = languageData.find(lang => lang.languageCode === languageCode);
  if (!lang) {
    return `Translation for ${key} in ${languageCode} not found.`;
  }
  return lang.translations[key] || `Translation for ${key} not found.`;
}

console.log(translate("hello", "en", languageData)); // Output: Hello
console.log(translate("hello", "es", languageData)); // Output: Hola
console.log(translate("welcome", "fr", languageData)); // Output: Bienvenue sur notre site web !
console.log(translate("missingKey", "de", languageData)); // Output: Translation for missingKey in de not found.

निष्कर्ष

टाइपस्क्रिप्ट जेनरिक पुन: प्रयोज्य, टाइप-सेफ कोड लिखने के लिए एक शक्तिशाली उपकरण हैं जो जटिल डेटा प्रकारों के साथ काम कर सकता है। जेनरिक के मूल सिंटैक्स, उन्नत सुविधाओं और सर्वोत्तम प्रथाओं को समझकर, आप अपने टाइपस्क्रिप्ट अनुप्रयोगों की गुणवत्ता और रखरखाव में काफी सुधार कर सकते हैं। वैश्विक दर्शकों के लिए एप्लिकेशन विकसित करते समय, जेनरिक आपको विविध डेटा प्रारूपों और सांस्कृतिक परंपराओं को संभालने में मदद कर सकते हैं, जिससे सभी के लिए एक सहज उपयोगकर्ता अनुभव सुनिश्चित होता है।